home *** CD-ROM | disk | FTP | other *** search
/ Giga Games 1 / Giga Games.iso / net / go / prog / sgf2mi13.taz / sgf2mi13 / sgfread.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-02-27  |  9.5 KB  |  462 lines
  1. /* #[info:            */
  2. /************************************************************************
  3.  *                                    *
  4.  *           ####  ####  ##### #####  #####    #    ####          *
  5.  *          #     #      #     #    # #       # #   #   #         *
  6.  *          #     #      #     #    # #      #   #  #    #        *
  7.  *           ###  #  ##  ###   #####  ###   ####### #    #        *
  8.  *              # #    # #     #  #   #     #     # #    #        *
  9.  *              # #    # #     #   #  #     #     # #   #         *
  10.  *          ####   ####  #     #    # ##### #     # ####          *
  11.  *                                    *
  12.  *                Jan van der Steen                *
  13.  *                                    *
  14.  *          Centre for Mathematics and Computer Science        *
  15.  *              Amsterdam, the Netherlands            *
  16.  *                                    *
  17.  *----------------------------------------------------------------------*
  18.  * File    : sgfread.c                         *
  19.  * Purpose : Read and store a Smart Go Format file            *
  20.  * Version : 1.2                         *
  21.  * Modified: 12/16/92 18:34:07                        *
  22.  * Author  : Jan van der Steen (jansteen@cwi.nl)             *
  23.  ************************************************************************/
  24. /* #]info:            */ 
  25. /* #[include:            */
  26.  
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <string.h>
  30. #include "tools.h"
  31. #include "gogame.h"
  32. #include "sgfread.h"
  33.  
  34. /* #]include:            */ 
  35. /* #[define:            */
  36.  
  37. #define MAXLINE    1024
  38.  
  39. /* #]define:            */ 
  40. /* #[typedef:            */
  41.  
  42. #ifdef __STDC__
  43. #    define    PROTO(s) s
  44. #else
  45. #    define    PROTO(s) ()
  46. #endif
  47.  
  48. typedef struct key_info {
  49.     char *        ky_long;
  50.     char *        ky_short;
  51.     void        (*ky_handle)PROTO((GOGAME *g, char *line));
  52. } KEY;
  53.  
  54. #undef PROTO
  55.  
  56. /* #]typedef:            */ 
  57. /* #[prototype:            */
  58.  
  59. #ifdef __STDC__
  60. #    define    PROTO(s) s
  61. #else
  62. #    define    PROTO(s) ()
  63. #endif
  64.  
  65. /*
  66.  * Keyword handlers
  67.  */
  68. static void    do_black     PROTO((GOGAME *g, char *line));
  69. static void    do_white     PROTO((GOGAME *g, char *line));
  70. static void    do_comment     PROTO((GOGAME *g, char *line));
  71. static void    do_event     PROTO((GOGAME *g, char *line));
  72. static void    do_user         PROTO((GOGAME *g, char *line));
  73. static void    do_playerblack     PROTO((GOGAME *g, char *line));
  74. static void    do_blackranking     PROTO((GOGAME *g, char *line));
  75. static void    do_playerwhite     PROTO((GOGAME *g, char *line));
  76. static void    do_whiteranking     PROTO((GOGAME *g, char *line));
  77. static void    do_date         PROTO((GOGAME *g, char *line));
  78. static void    do_game         PROTO((GOGAME *g, char *line));
  79. static void    do_view         PROTO((GOGAME *g, char *line));
  80. static void    do_size         PROTO((GOGAME *g, char *line));
  81. static void    do_gamename     PROTO((GOGAME *g, char *line));
  82. static void    do_place     PROTO((GOGAME *g, char *line));
  83. static void    do_result     PROTO((GOGAME *g, char *line));
  84. static void    do_komi         PROTO((GOGAME *g, char *line));
  85. static void    do_addblack     PROTO((GOGAME *g, char *line));
  86. static void    do_addwhite     PROTO((GOGAME *g, char *line));
  87. static void    do_blacktimeleft PROTO((GOGAME *g, char *line));
  88. static void    do_whitetimeleft PROTO((GOGAME *g, char *line));
  89.  
  90. #undef PROTO
  91.  
  92. /* #]prototype:            */ 
  93. /* #[static:            */
  94.  
  95. static KEY key[] = {
  96.     {    "Black"        ,  "B"         , do_black        },
  97.     {    "White"        ,  "W"         , do_white        },
  98.     {    "Comment"    ,  "C"         , do_comment        },
  99.     {    "EVent"        ,  "EV"        , do_event        },
  100.     {    "USer"        ,  "US"        , do_user        },
  101.     {    "PlayerBlack"    ,  "PB"        , do_playerblack    },
  102.     {    "BlackRanking"    ,  "BR"        , do_blackranking    },
  103.     {    "PlayerWhite"    ,  "PW"        , do_playerwhite    },
  104.     {    "WhiteRanking"    ,  "WR"        , do_whiteranking    },
  105.     {    "DaTe"        ,  "DT"        , do_date        },
  106.     {    "GaMe"        ,  "GM"        , do_game        },
  107.     {    "VieW"        ,  "VW"        , do_view        },
  108.     {    "SiZe"        ,  "SZ"        , do_size        },
  109.     {    "GameName"    ,  "GN"        , do_gamename        },
  110.     {    "PlaCe"        ,  "PC"        , do_place        },
  111.     {    "REsult"    ,  "RE"        , do_result        },
  112.     {    "KoMi"        ,  "KM"        , do_komi        },
  113.     {    "AddBlack"    ,  "AB"        , do_addblack        },
  114.     {    "AddWhite"    ,  "AW"        , do_addwhite        },
  115.     {    "BlacktimeLeft"    ,  "BL"        , do_blacktimeleft    },
  116.     {    "WhitetimeLeft"    ,  "WL"        , do_whitetimeleft    },
  117.     {    (char *) 0    ,  (char *) 0    , 0            }
  118. };
  119.  
  120. static    FILE *input;
  121.  
  122. /* #]static:            */ 
  123.  
  124. /* #[do_black:            */
  125.  
  126. static void
  127. do_black(gogame, line)
  128. GOGAME *gogame;
  129. char   *line;
  130. {
  131.     int        i    = *(line  ) - 'a';
  132.     int        j    = *(line+1) - 'a';
  133.     PLACE    place    = i + (j * gogame->gm_size);
  134.  
  135.     move_store(gogame, BLACK, place);
  136. }
  137.  
  138. /* #]do_black:            */ 
  139. /* #[do_white:            */
  140.  
  141. static void
  142. do_white(gogame, line)
  143. GOGAME *gogame;
  144. char   *line;
  145. {
  146.     int        i    = *(line  ) - 'a';
  147.     int        j    = *(line+1) - 'a';
  148.     PLACE    place    = i + (j * gogame->gm_size);
  149.  
  150.     move_store(gogame, WHITE, place);
  151. }
  152.  
  153. /* #]do_white:            */ 
  154. /* #[do_addblack:        */
  155.  
  156. static void
  157. do_addblack(gogame, line)
  158. /*
  159.  * Add a black stone to the game
  160.  * TODO: Make it accept: [dp][pd][..]
  161.  */
  162. GOGAME *gogame;
  163. char   *line;
  164. {
  165.     int        i    = *(line  ) - 'a';
  166.     int        j    = *(line+1) - 'a';
  167.     PLACE    place    = i + (j * gogame->gm_size);
  168.  
  169.     move_store(gogame, BLACK, place);
  170.     gogame->gm_movenr--;
  171. }
  172.  
  173. /* #]do_addblack:        */ 
  174. /* #[do_addwhite:        */
  175.  
  176. static void
  177. do_addwhite(gogame, line)
  178. /*
  179.  * Add a white stone to the game
  180.  * TODO: Make it accept: [dp][pd][..]
  181.  */
  182. GOGAME *gogame;
  183. char   *line;
  184. {
  185.     int        i    = *(line  ) - 'a';
  186.     int        j    = *(line+1) - 'a';
  187.     PLACE    place    = i + (j * gogame->gm_size);
  188.  
  189.     move_store(gogame, BLACK, place);
  190.     gogame->gm_movenr--;
  191. }
  192.  
  193. /* #]do_addwhite:        */ 
  194. /* #[do_comment:        */
  195.  
  196. static void
  197. do_comment(gogame, line)
  198. GOGAME *gogame;
  199. char   *line;
  200. {
  201.     char nextline[MAXLINE];
  202.  
  203.     if (gogame->gm_movelast == (GOMOVE *) 0) {
  204.     fprintf(stderr, "Comment without move received (ignored)\n");
  205.     return;
  206.     }
  207.     if (*line) text_store(gogame, line);
  208.     while (fgets(nextline, MAXLINE, input) != (char *) 0) {
  209.     if (*nextline == /*[*/ ']') return;
  210.     nextline[strlen(nextline) - 1] = 0;
  211.     text_store(gogame, nextline);
  212.     }
  213. }
  214.  
  215. /* #]do_comment:        */ 
  216. /* #[do_event:            */
  217.  
  218. static void
  219. do_event(gogame, line)
  220. GOGAME *gogame;
  221. char   *line;
  222. {
  223.     gogame->gm_event = string_store(line);
  224. }
  225.  
  226. /* #]do_event:            */ 
  227. /* #[do_user:            */
  228.  
  229. static void
  230. do_user(gogame, line)
  231. GOGAME *gogame;
  232. char   *line;
  233. {
  234.     gogame->gm_user = string_store(line);
  235. }
  236.  
  237. /* #]do_user:            */ 
  238. /* #[do_playerblack:        */
  239.  
  240. static void
  241. do_playerblack(gogame, line)
  242. GOGAME *gogame;
  243. char   *line;
  244. {
  245.     gogame->gm_black = string_store(line);
  246. }
  247.  
  248. /* #]do_playerblack:        */ 
  249. /* #[do_blackranking:        */
  250.  
  251. static void
  252. do_blackranking(gogame, line)
  253. GOGAME *gogame;
  254. char   *line;
  255. {
  256.     gogame->gm_brank = string_store(line);
  257. }
  258.  
  259. /* #]do_blackranking:        */ 
  260. /* #[do_blacktimeleft:        */
  261.  
  262. static void
  263. do_blacktimeleft(gogame, line)
  264. GOGAME *gogame;
  265. char   *line;
  266. {
  267.     gogame->gm_btime = string_store(line);
  268. }
  269.  
  270. /* #]do_blacktimeleft:        */ 
  271. /* #[do_playerwhite:        */
  272.  
  273. static void
  274. do_playerwhite(gogame, line)
  275. GOGAME *gogame;
  276. char   *line;
  277. {
  278.     gogame->gm_white = string_store(line);
  279. }
  280.  
  281. /* #]do_playerwhite:        */ 
  282. /* #[do_whiteranking:        */
  283.  
  284. static void
  285. do_whiteranking(gogame, line)
  286. GOGAME *gogame;
  287. char   *line;
  288. {
  289.     gogame->gm_wrank = string_store(line);
  290. }
  291.  
  292. /* #]do_whiteranking:        */ 
  293. /* #[do_whitetimeleft:        */
  294.  
  295. static void
  296. do_whitetimeleft(gogame, line)
  297. GOGAME *gogame;
  298. char   *line;
  299. {
  300.     gogame->gm_wtime = string_store(line);
  301. }
  302.  
  303. /* #]do_whitetimeleft:        */ 
  304. /* #[do_date:            */
  305.  
  306. static void
  307. do_date(gogame, line)
  308. GOGAME *gogame;
  309. char   *line;
  310. {
  311.     gogame->gm_date = string_store(line);
  312. }
  313.  
  314. /* #]do_date:            */ 
  315. /* #[do_game:            */
  316.  
  317. static void
  318. do_game(gogame, line)
  319. GOGAME *gogame;
  320. char   *line;
  321. {
  322.     gogame->gm_game = string_store(line);
  323. }
  324.  
  325. /* #]do_game:            */ 
  326. /* #[do_view:            */
  327.  
  328. static void
  329. do_view(gogame, line)
  330. GOGAME *gogame;
  331. char   *line;
  332. {
  333.     gogame->gm_view = string_store(line);
  334. }
  335.  
  336. /* #]do_view:            */ 
  337. /* #[do_size:            */
  338.  
  339. static void
  340. do_size(gogame, line)
  341. GOGAME *gogame;
  342. char   *line;
  343. {
  344.     int size = atoi(line);
  345.  
  346.     if (size != MAXSIZE) {
  347.     free(gogame->gm_goban);
  348.     gogame->gm_goban = goban_new(gogame, size);
  349.     }
  350.     gogame->gm_size = size;
  351. }
  352.  
  353. /* #]do_size:            */ 
  354. /* #[do_gamename:        */
  355.  
  356. static void
  357. do_gamename(gogame, line)
  358. GOGAME *gogame;
  359. char   *line;
  360. {
  361.     gogame->gm_name = string_store(line);
  362. }
  363.  
  364. /* #]do_gamename:        */ 
  365. /* #[do_place:            */
  366.  
  367. static void
  368. do_place(gogame, line)
  369. GOGAME *gogame;
  370. char   *line;
  371. {
  372.     gogame->gm_place = string_store(line);
  373. }
  374.  
  375. /* #]do_place:            */ 
  376. /* #[do_result:            */
  377.  
  378. static void
  379. do_result(gogame, line)
  380. GOGAME *gogame;
  381. char   *line;
  382. {
  383.     gogame->gm_result = string_store(line);
  384. }
  385.  
  386. /* #]do_result:            */ 
  387. /* #[do_komi:            */
  388.  
  389. static void
  390. do_komi(gogame, line)
  391. GOGAME *gogame;
  392. char   *line;
  393. {
  394.     gogame->gm_komi = string_store(line);
  395. }
  396.  
  397. /* #]do_komi:            */ 
  398.  
  399. /* #[sgf_read:            */
  400.  
  401. GOGAME *
  402. sgf_read(fp)
  403. FILE *fp;
  404. {
  405.     GOGAME *    gogame = (GOGAME *) 0;
  406.     KEY     *    k;
  407.     char    line[MAXLINE];
  408.     char *    o_bracket;
  409.  
  410.     input = fp;
  411.     while (fgets(line, MAXLINE, fp) != (char *) 0) {
  412.     /*
  413.      * First try one character directives
  414.      */
  415.     switch (*line) {
  416.         case '(':    if (gogame == (GOGAME *) 0) {
  417.                 gogame = game_alloc();
  418.             } else {
  419.                 fprintf(stderr, "Recursive game encountered!\n");
  420.                 exit(1);
  421.             }
  422.             continue;
  423.         case ';':    continue;
  424.         case ')':    return gogame;
  425.         default:    break;
  426.     }
  427.     /*
  428.      * Next try keywords
  429.      */
  430.     if (gogame == (GOGAME *) 0) continue;
  431.     line[strlen(line) - 1] = 0;
  432.     o_bracket = strchr(line, '['/*]*/);
  433.     if (!o_bracket) {
  434.         fprintf(stderr,
  435.             "No opening bracket in line: \"%s\"\n", line);
  436.         continue;
  437.     }
  438.     *o_bracket = 0;
  439.     for (k = key; k->ky_long != (char *) 0; k++) {
  440.         if (!strncmp(line, k->ky_long , strlen(line)) ||
  441.         !strncmp(line, k->ky_short, strlen(line))) {
  442.         if (k->ky_handle) {
  443.             char *c_bracket = strchr(o_bracket+1, /*[*/']');
  444.  
  445.             if (c_bracket) *c_bracket = 0;
  446.             (k->ky_handle)(gogame, o_bracket+1);
  447.             break;
  448.         } else fprintf(stderr, "Not supported: \"%s\"\n", line);
  449.         }
  450.     }
  451.     }
  452.     if (gogame != (GOGAME *) 0) {
  453.     fprintf(stderr, "sgf_read(): EOF encountered before End Of Game\n");
  454.     game_free(gogame);
  455.     gogame = (GOGAME *) 0;
  456.     }
  457.     return gogame;
  458. }
  459.  
  460. /* #]sgf_read:            */ 
  461.  
  462.